/*******************************************************************************
** Rangos.h: contiene todo lo necesario para trabajar con la solapa
**             Eval. rangos.
**
** author: M-S Hernández-García
**
**  This file is part of TEIDE2.
**
**  TEIDE2 is free software: you can redistribute it and/or modify
**  it under the terms of the GNU General Public License as published by
**  the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  Foobar is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
**
*******************************************************************************/

#ifndef RANGOS_H
#define RANGOS_H

#include <QShortcut>
#include <QVariant>
#include <QAction>
#include <QApplication>
#include <QButtonGroup>
#include <QComboBox>
#include <QFrame>
#include <QGroupBox>
#include <QLabel>
#include <QLineEdit>
#include <QProgressBar>
#include <QPushButton>
#include <QSpinBox>
#include <QWidget>
#include <QClipboard>
#include <QTableView>
#include "TablaModelInfoR.h"
#include "TablaModelR.h"
#include "Edits.h"
#include "IrAVariable.h"
#include "CambiarMicrodato.h"
#include "ExpAna.h"
#include "MiBox.h"
#include <QTabWidget>

class TFmeRangos : public QWidget
{
    Q_OBJECT

public:

    QFrame *PanContenedor;
    QFrame *SplSeparador;    
    MiTabla *view;     // vista de la tabla principal
    MiTabla *view2;    // vista de la tabla registro
    MiTabla *view3;    // vista de la tabla variable    
    QFrame *PanExclusion;
    QLabel *LabExclusionRegistros;
    QLineEdit *EdtExclusionRegistros;
    QLabel *LabExclusionVariables;
    QLineEdit *EdtExclusionVariables;
    QPushButton *ButAplicarExclusion;    
    MiBox *GbxHistograma;    
    QFrame *PanInfo;
    QLabel *LabIrAVariablePorNombre;
    QLabel *LabIrAVariablePorNumero;
    QLabel *LabIrARegistroPorNumero;
    QLabel *LabIrARegistroPorNombre;
    QFrame *SbrBarraNum;
    QLabel *LabNumFiltrosVariable;
    QLabel *LabNumEditsVariable;
    QLineEdit *EdtIrARegistroPorNumero;
    QComboBox *CbxIrARegistroPorNombre;
    QComboBox *CbxIrAVariablePorNombre;
    QLineEdit *EdtIrAVariablePorNumero;
    QLineEdit *EdtNumFiltrosVariable;
    QLineEdit *EdtNumEditsVariable;
    QFrame *SbrBarraEstado;
    QFrame *SbrBarraEstado1;
    QLabel *LabSbrBarraEstado1;
    QFrame *SbrBarraEstado2;
    QLabel *LabSbrBarraEstado2;
    QFrame *PanSalvarPorcentajesError;
    QLabel *LabUmbralErrorVariables;
    QLabel *Label1;
    QLabel *LabUmbralErrorRegistros;
    QLabel *Label3;
    QPushButton *ButSalvarErrorVariables;
    QPushButton *ButSalvarErrorRegistros;
    QSpinBox *EdtUmbralErrorVariables;
    QSpinBox *EdtUmbralErrorRegistros;
    QLineEdit *PanProgreso;
    QLabel *LabProgreso;
    QLabel *LabOperacion;
    QLabel *LabPorcentaje;
    QLabel *LabElemento;
    QLineEdit *EdtOperacion;
    QProgressBar *PbrProgreso;
    QLineEdit *EdtPorcentaje;
    QLineEdit *EdtElemento;
    QMenu * menu;
    QComboBox *VisualizarReg;

    TFmeRangos(QWidget* parent, const char* name, Qt::WindowFlags fl, TFmeEdits *FmeEditsAsociados, TFrmIrAVariable *FrmIrAVariable, TFrmCambiarMicrodato *FrmCambiarMicrodato, TFrmOpciones *FrmOpciones, QTabWidget *Frmprincipal, QStringList *ListaIds);
    void ajustarSize();

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Asociar las clases provenientes de etapas anteriores.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void AsociarClases(TFmeEdits *FmeEditsAsociados);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Actualizar los umbrales de errores de exclusion.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ActualizarUmbralExclusion();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Aplicar los porcentajes de exclusion y recalcular los resultados.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void AplicarExclusion();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Actualizar la evaluacion y toda la interface despues de haber modificado un microdato concreto.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ActualizarInterfaceMicrodatoCambiado(unsigned IndiceRegistro, unsigned IndiceVariable, double Valor);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Actualizar los datos de la evaluacion del registro.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    bool EvaluacionEditRegistro(unsigned IndiceRegistro, unsigned IndiceEdit);
    bool EvaluacionFiltroRegistro(unsigned IndiceRegistro, unsigned IndiceEdit);
    bool EstaCargado();
    bool FiltroExcluido(unsigned IndiceVariable);
    double GetPorcentajeErrorVariable(unsigned IndiceVariable);
    double GetPorcentajeErrorRegistro(unsigned IndiceRegistro);
    unsigned GetNumeroErrorVariable(unsigned IndiceVariable) ;
    unsigned GetNumeroErrorRegistro(unsigned IndiceRegistro);
    TFmeEdits *GetEditsAsociados();
    bool GetTest(unsigned IndiceRegistro, unsigned IndiceVariable);
    bool GetTestCondicionFiltro(unsigned IndiceRegistro, unsigned IndiceVariable);
    unsigned GetUmbralExclusionRegistros();
    unsigned GetUmbralExclusionVariables();
    QSet<unsigned> GetVariablesExcluidas();
    QSet<unsigned> GetRegistrosExcluidos();
    double GetTiempoProcesoSegundos();
    double GetTiempoProcesoMilisegundos();
    unsigned GetNumRegistrosCorrectos();
    unsigned GetNumRegistrosIncorrectos();
    unsigned GetNumRegistrosExcluidosAPriori();
    unsigned GetNumRegistrosExcluidos();
    unsigned GetNumVariablesCorrectas();
    unsigned GetNumVariablesIncorrectas();
    unsigned GetNumVariablesExcluidasAPriori();
    unsigned GetNumVariablesExcluidas();
    bool RegistroCorrecto(unsigned IndiceRegistro);
    bool RegistroExcluido(unsigned IndiceRegistro);
    bool VariableCorrecta(unsigned IndiceVariable);
    bool VariableExcluida(unsigned IndiceVariable);
    bool *GetVectorExclusionVariables();
    bool VarModFiltro(QSet<unsigned> VarFiltro, QSet<unsigned> VarModificadas);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Actualizar los datos de la evaluacion del registro.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    bool ActualizarEvaluacionRegistro(unsigned IndiceRegistro, bool MicrodatoModificado);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Buscar la siguiente variable de la rejilla registro del filtro.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    unsigned BuscarVariableDerecha(unsigned ColumnaOrigen);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Buscar la anterior variable de la rejilla registro del filtro.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    unsigned BuscarVariableIzquierda(unsigned ColumnaOrigen);

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Buscar la siguiente variable con error hacia la derecha.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    unsigned BuscarVariableErrorDerecha(unsigned FilaOrigen, unsigned ColumnaOrigen);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Buscar la siguiente variable con error hacia la izquierda.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    unsigned BuscarVariableErrorIzquierda(unsigned FilaOrigen, unsigned ColumnaOrigen);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Buscar el siguiente microdato erroneo hacia arriba.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    unsigned BuscarMicroDatoErrorArriba(unsigned FilaOrigen, unsigned ColumnaOrigen);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Buscar el siguiente microdato erroneo hacia abajo.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    unsigned BuscarMicroDatoErrorAbajo(unsigned FilaOrigen, unsigned ColumnaOrigen);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Cargar las Variables y los Registros posibles en la lista desplegable.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CargarEnLista();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Cargar el test en la rejilla de visualizacion.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CargarTestEnRejilla();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Cargar el test del registro en la rejilla de visualizacion.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CargarTestRegistroEnRejilla(unsigned IndiceRegistro);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Cargar porcentajes en la rejilla y en las series de datos.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CargarResultados();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Cargar porcentajes en la rejilla y en las series de datos para el registro especificado.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CargarResultadosRegistro(unsigned IndiceRegistro);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Cargar porcentajes en la rejilla y en las series de datos para la variable especificada.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CargarResultadosVariable(unsigned IndiceVariable);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copiar el vector de totales originales en el vector de totales temporal.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CrearCopiaVectoresTotales();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Calcular numero de registros correctos.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    unsigned CalcularNumRegistrosCorrectos();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Calcular numero de variables correctas.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    unsigned CalcularNumVariablesCorrectas();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Calcular numeros de resumen.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CalcularNumResumen();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Evaluar el registro que se pasa por parametros sobre los filtros.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    bool ResultadoTestear(bool ResultadoFiltro, double Valor, int NP, QString opcion, int var);
    bool EvaluarFiltros(unsigned IndiceRegistro, QSet<unsigned> VariablesModificadas, QMap<QString,double> *MapTest);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Excluir el registro por parametros.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ExcluirRegistro(unsigned IndiceRegistro);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Excluir la variable por parametros.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ExcluirVariable(unsigned IndiceVariable);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Excluir los filtros afectados por la variable.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ExcluirFiltros(unsigned IndiceVariable);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Excluir los registros que estan por encima del umbral especificado.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ExcluirRegistros();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Excluir las variables que estan por encima del umbral especificado.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ExcluirVariables();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Excluir los registros a priori.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ExcluirRegistrosAPriori();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Excluir los variables a priori.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ExcluirVariablesAPriori();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Fijar la cantidad de datos que intervienen en el proceso.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void FijarCantidadDatos();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Dice si el filtro se cumple o no.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    bool GetTestFiltro(unsigned IndiceRegistro, unsigned IndiceVariable);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    QComboBox *GetVisualizarReg();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Dice si el rango se cumple o no.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    bool GetTestRango(unsigned IndiceRegistro, unsigned IndiceVariable);
//////////////////////////////////////////////////////////////////////////////
    TablaModelR *GetTablaModel();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Incluir el registro por parametros.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void IncluirRegistro(unsigned IndiceRegistro);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Incluir la variable por parametros.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void IncluirVariable(unsigned IndiceVariable);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Incluir los filtros afectados por la variable.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void IncluirFiltros(unsigned IndiceVariable);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicializar la rejilla de visualizacion general.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void InicializarRejilla();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicializar la rejilla de visualizacion de registros.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void InicializarRejillaRegistro();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicializar la rejilla de visualizacion de Variables.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void InicializarRejillaVariable();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Fijar el ancho de las columnas de la rejilla principal y rejilla registro.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void FijarAnchoColumnasRejilla(unsigned ancho);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicializar la matriz de test y la matriz de test de filtros
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void InicializarMatrizTest();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicializar la matriz de test de filtros.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void InicializarMatrizTestFiltro();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicializar los vectores de totales.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void InicializarVectoresTotales();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicializar los vectores de exclusion.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void InicializarVectoresExclusion();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicializar los cuadros de exclusion.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void InicializarCuadrosExclusion();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicializar el sistema de progreso.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void InicSistemaProgreso();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Incrementar el sistema de progreso.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void IncSistemaProgreso();
    QString SustCaracter(QString Cadena, char CarABuscar, char CarSustitucion);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Mostrar la informacion asociada a la fila y a la columna.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void MostrarInfoAsociada(unsigned Fila, unsigned Columna, bool Fijar);
    void MostrarInfoAsociada(unsigned Fila, unsigned Columna, unsigned numreg, bool Fijar, QStringList listah, QString **matriz, QStringList listav);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Resetear los vectores de totales y los vectores de exclusion
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ResetearVectoresTotales();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Resetear los vectores de exclusion.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ResetearVectoresExclusion();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Resetear las listas de exclusion.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ResetearListasExclusion();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Resetear las listas de exclusion a priori.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ResetearListasExclusionAPriori();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Salvar en un fichero los porcentajes de error de las variables.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void SalvarPorcentajesErrorVariables(QString NombreFichero, double PorcentajeUmbral);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Salvar en un fichero los porcentajes de error de los registros.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void SalvarPorcentajesErrorRegistros(QString NombreFichero, double PorcentajeUmbral);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Validar los rangos de las variables.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ValidarRangos();
    void InicSistemaProgreso2(QString tex);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Incrementar el sistema de progreso.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void IncSistemaProgreso2(QString tex);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Pinta la rejilla variable.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void repintarVariable(bool filtro, bool falso);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Pinta la rejilla registro.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void repintarRegistro(int col, bool falso);

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


public slots:

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PULSAR EL BOTON DE APLICAR LA EXCLUSION.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ButAplicarExclusionClick();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SELECCIONAR UNA VARIABLE DEL COMBOBOX DE IR A VARIABLES.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void CbxIrAVariablePorNombreCloseUp(int index);
    
    void CbxIrARegistroPorNombreCloseUp(int index);

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PULSAR UNA TECLA SOBRE EL EDIT DE IR A REGISTRO.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void EdtIrARegistroPorNumeroKeyDown();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PULSAR UNA TECLA SOBRE EL EDIT DE IR A VARIABLE POR NUMERO.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void EdtIrAVariablePorNumeroKeyDown();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// COPIAR EL IDENTIFICADOR DEL REGISTRO ACTUAL.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void MitCopiarIdentificadorRegistroClick();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// COPIAR EL IDENTIFICADOR DE LA VARIABLE ACTUAL.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void MitCopiarIdentificadorVariableClick();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SELECCIONAR UNA CELDA DE LA REJILLA.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void SgrRejillaSelectCell(const QModelIndex& index);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SELECCIONAR UNA CELDA DE LA REJILLA VARIABLE.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void SgrRejillaSelectCellV(const int& index);
    void SgrRejillaSelectCellH(const int& index); 

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PULSAR UNA TECLA SOBRE LA REJILLA REGISTRO.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void SgrRejillaRegKeyDownCR();
    void SgrRejillaRegKeyDownCL();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PULSAR UNA TECLA SOBRE LA REJILLA PRINCIPAL.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void SgrRejillaKeyDownAR();
    void SgrRejillaKeyDownAL();
    void SgrRejillaKeyDownAU();
    void SgrRejillaKeyDownAD();
    void SgrRejillaKeyDownCZ();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// HACER DOBLE CLICK SOBRE LA REJILLA DE VARIABLE.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void SgrRejillaVariableDblClick(const QModelIndex& index);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// HACER DOBLE CLICK SOBRE LA REJILLA DE REGISTRO.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void SgrRejillaRegistroDblClick(const QModelIndex& index);

    void ButAplicarIrAVariableClickR();
    void ButCancelarIrAVariableClickR();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PULSAR EL BOTON DE SALVAR ERROR VARIABLES.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ButSalvarErrorVariablesClick();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PULSAR EL BOTON DE SALVAR ERROR REGISTROS.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void ButSalvarErrorRegistrosClick();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// HACER DOBLE CLICK SOBRE LA REJILLA PRINCIPAL.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void SgrRejillaDblClick(const QModelIndex& index);
    
    void ButAceptarCambiarMicrodatoClickR();

    void ButCancelarCambiarMicrodatoClickR();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PINCHAR LA OPCION DE MENU DE AUMENTAR EL TAMAÑO DE LAS COLUMNAS.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void MitAumentarColumnasClick();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// PINCHAR LA OPCION DE MENU DE DISMINUIR EL TAMAÑO DE LAS COLUMNAS.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void MitDisminuirColumnasClick();

    void VisualizarMenu(const QModelIndex& index);
    
    void ButClick_sig();
    void ButClick_ant();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MODO DE VISUALIZAR LA TABLA DE RANGOS.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    void VisualizarRegCloseUp(int index);

private:

  TFrmCambiarMicrodato *FrmCambiarMicrodato;
  TFmeEdits *FmeEditsAsociados;
  TFmeMicroDatos *FmeMicroDatosAsociados;
  TFmeVariables *FmeVariablesAsociadas;
  TFrmOpciones *FrmOpciones;
  QTabWidget *principal;
  TFrmIrAVariable *FrmIrAVariable;

  QString Name;
  unsigned NumRegistrosEnRango;
  unsigned NumRegistros;
  unsigned NumVariables;
  unsigned *VectorTotalesPorFilas;
  unsigned *VectorTotalesPorColumnas;
  unsigned *VectorTotalesPorFilasOriginal;
  unsigned *VectorTotalesPorColumnasOriginal;
  QStringList *ListaVariables;
  QStringList *ListaIds;
  bool **MatrizTest;
  QString **MatrizTestS;
  QStringList listaH;
  QStringList listaV;
  bool **MatrizTestFiltro;
  bool *VectorExclusionRegistros;
  bool *VectorExclusionVariables;
  bool *VectorExclusionFiltros;
  bool Cargado;
  QSet<unsigned> VariablesExcluidas;
  QSet<unsigned> RegistrosExcluidos;
  QSet<unsigned> VariablesExcluidasAPriori;
  QSet<unsigned> RegistrosExcluidosAPriori;
  QTime InstanteComienzo;
  QTime InstanteFinalizacion;
  unsigned NumRegistrosCorrectos;
  unsigned NumRegistrosIncorrectos;
  unsigned NumRegistrosExcluidosAPriori;
  unsigned NumRegistrosExcluidos;
  unsigned NumVariablesCorrectas;
  unsigned NumVariablesIncorrectas;
  unsigned NumVariablesExcluidasAPriori;
  unsigned NumVariablesExcluidas;
  unsigned UmbralExclusionRegistros, UmbralExclusionVariables;
  bool ModificacionMicrodato;
  double UltimoMicrodatoModificado;
  double UltimoIndiceRegistroModificado;
  double UltimoIndiceVariableModificado;

  QTextEdit *MemLogs;  
  TablaModelR *model;
  TablaModelInfoR *model2;
  QStringList listaH2;
  QStringList listaV2;
  QString *VectorDatosR;
  TablaModelInfoR *model3;
  QStringList listaH3;
  QStringList listaV3;
  QString *VectorDatosV;
  bool rejillaregistro;
};

#endif // RANGOS_H
